package cn.harry.cabinet.repository

import android.app.Application
import cn.harry.cabinet.dao.CardDao
import cn.harry.cabinet.database.AppDatabase
import cn.harry.cabinet.model.entity.Card
import java.util.Date

/**
 * 卡片仓库
 */
class CardRepository(application: Application) : BaseRepository() {
    
    private val cardDao: CardDao = AppDatabase.getDatabase(application).cardDao()
    
    /**
     * 插入卡片
     * @throws IllegalArgumentException 如果卡号已存在
     */
    suspend fun insert(card: Card): Long {
        // 校验卡号唯一性
        if (existsByCardNumber(card.cardNumber)) {
            throw IllegalArgumentException("卡号 '${card.cardNumber}' 已存在，请使用其他卡号")
        }
        return cardDao.insert(card)
    }
    
    /**
     * 批量插入卡片
     * @throws IllegalArgumentException 如果任何卡号已存在
     */
    suspend fun insertAll(cards: List<Card>) {
        // 校验所有卡号唯一性
        val duplicateCardNumbers = cards.filter { existsByCardNumber(it.cardNumber) }
            .map { it.cardNumber }
        
        if (duplicateCardNumbers.isNotEmpty()) {
            throw IllegalArgumentException("以下卡号已存在: ${duplicateCardNumbers.joinToString(", ")}")
        }
        
        // 检查批量插入的卡片中是否有重复卡号
        val cardNumbers = cards.map { it.cardNumber }
        val duplicatesInBatch = cardNumbers.groupingBy { it }.eachCount().filter { it.value > 1 }.keys
        
        if (duplicatesInBatch.isNotEmpty()) {
            throw IllegalArgumentException("批量插入的卡片中存在重复卡号: ${duplicatesInBatch.joinToString(", ")}")
        }
        
        cardDao.insertAll(cards)
    }
    
    /**
     * 更新卡片
     * @throws IllegalArgumentException 如果卡号已被其他卡片使用
     */
    suspend fun update(card: Card) {
        // 校验卡号唯一性（排除当前卡片ID）
        if (cardDao.existsByCardNumberExcludingId(card.cardNumber, card.id) > 0) {
            throw IllegalArgumentException("卡号 '${card.cardNumber}' 已被其他卡片使用，请使用其他卡号")
        }
        
        val updatedCard = card.copy(updateTime = Date())
        cardDao.update(updatedCard)
    }
    
    /**
     * 删除卡片
     */
    suspend fun delete(card: Card) {
        cardDao.delete(card)
    }
    
    /**
     * 根据ID删除卡片
     */
    suspend fun deleteById(cardId: Long) {
        cardDao.deleteById(cardId)
    }
    
    /**
     * 根据ID查询卡片
     */
    suspend fun getById(cardId: Long): Card? {
        return cardDao.getById(cardId)
    }
    
    /**
     * 根据卡号查询卡片
     */
    suspend fun getByCardNumber(cardNumber: String): Card? {
        return cardDao.getByCardNumber(cardNumber)
    }
    
    /**
     * 查询所有卡片
     */
    suspend fun getAll(): List<Card> {
        return cardDao.getAll()
    }
    
    /**
     * 根据类型查询卡片
     */
    suspend fun getByType(type: String): List<Card> {
        return cardDao.getByType(type)
    }
    
    /**
     * 根据状态查询卡片
     */
    suspend fun getByStatus(status: String): List<Card> {
        return cardDao.getByStatus(status)
    }
    
    /**
     * 搜索卡片
     */
    suspend fun search(keyword: String): List<Card> {
        return cardDao.search(keyword)
    }
    
    /**
     * 统计卡片总数
     */
    suspend fun count(): Int {
        return cardDao.count()
    }
    
    /**
     * 统计指定状态的卡片数量
     */
    suspend fun countByStatus(status: String): Int {
        return cardDao.countByStatus(status)
    }
    
    /**
     * 检查卡号是否已存在
     */
    suspend fun existsByCardNumber(cardNumber: String): Boolean {
        return cardDao.existsByCardNumber(cardNumber) > 0
    }
    
    /**
     * 更新卡片状态
     */
    suspend fun updateStatus(cardId: Long, status: String) {
        cardDao.updateStatus(cardId, status, Date().time)
    }
    
    /**
     * 启用卡片
     */
    suspend fun enableCard(cardId: Long) {
        updateStatus(cardId, Card.STATUS_ENABLED)
    }
    
    /**
     * 禁用卡片
     */
    suspend fun disableCard(cardId: Long) {
        updateStatus(cardId, Card.STATUS_DISABLED)
    }
}
